/**
 * 道具管理器
 * 负责游戏中的道具系统
 */
class ItemManager {
    constructor(game) {
        // 游戏实例引用
        this.game = game;
        
        // 道具列表
        this.items = [];
        
        // 当前持有的道具
        this.currentItem = null;
        
        // 道具显示元素
        this.itemDisplay = document.getElementById('item-display');
        
        // 道具生成概率 (每10个正确输入的概率)
        this.itemChance = 0.3;
        
        // 道具类型定义
        this.itemTypes = {
            banana: {
                name: '香蕉皮',
                description: '让警察减速',
                duration: 5, // 持续5秒
                effect: 'slowPolice'
            },
            coffee: {
                name: '咖啡',
                description: '提高打字速度',
                duration: 5, // 持续5秒
                effect: 'speedBoost'
            },
            shield: {
                name: '护盾',
                description: '免疫一次错误',
                duration: 0, // 一次性使用
                effect: 'errorShield'
            }
        };
        
        // 音频管理器
        this.audioManager = new AudioManager();
        
        // 是否有护盾激活
        this.hasShieldActive = false;
        
        // 打字加速结束时间
        this.typingBoostEndTime = 0;
    }
    
    /**
     * 初始化道具系统
     */
    init() {
        // 重置状态
        this.reset();
        
        // 更新道具显示
        this.updateItemDisplay();
    }
    
    /**
     * 检查是否生成道具
     * @param {number} consecutiveCorrect 连续正确输入数
     */
    checkItemGeneration(consecutiveCorrect) {
        // 每10个连续正确输入，有机会生成道具
        if (consecutiveCorrect > 0 && consecutiveCorrect % 10 === 0) {
            const random = Math.random();
            
            if (random < this.itemChance) {
                this.generateRandomItem();
            }
        }
    }
    
    /**
     * 生成随机道具
     */
    generateRandomItem() {
        // 如果已有道具，不生成新道具
        if (this.currentItem) {
            return;
        }
        
        // 获取所有道具类型
        const itemKeys = Object.keys(this.itemTypes);
        
        // 随机选择一种道具
        const randomIndex = Math.floor(Math.random() * itemKeys.length);
        const itemType = itemKeys[randomIndex];
        
        // 创建道具
        this.currentItem = {
            type: itemType,
            ...this.itemTypes[itemType],
            active: false,
            startTime: 0,
            endTime: 0
        };
        
        // 更新道具显示
        this.updateItemDisplay();
        
        console.log(`获得道具: ${this.currentItem.name}`);
    }
    
    /**
     * 使用当前道具
     */
    useItem() {
        if (!this.currentItem) {
            console.log('没有可用的道具');
            return;
        }
        
        console.log(`使用道具: ${this.currentItem.name}`);
        
        // 显示道具使用效果
        this.showItemEffect(this.currentItem.type);
        
        // 根据道具类型执行不同效果
        switch (this.currentItem.type) {
            case 'banana':
                // 让警察减速
                this.game.policeAI.slowDown(this.currentItem.duration);
                break;
            case 'coffee':
                // 提高打字速度
                // 实现方式：暂时增加WPM计算的权重
                this.typingBoostEndTime = Date.now() + 5000; // 5秒加速
                break;
            case 'shield':
                // 设置护盾
                this.hasShieldActive = true;
                break;
        }
        
        // 播放使用道具音效
        if (this.game.audioManager) {
            this.game.audioManager.playSound('useItem');
        }
        
        // 清除道具
        this.currentItem = null;
        
        // 更新UI
        this.updateItemDisplay();
    }
    
    /**
     * 显示道具使用效果
     * @param {string} itemType 道具类型
     */
    showItemEffect(itemType) {
        const gameScene = document.getElementById('game-scene');
        if (!gameScene) return;
        
        // 创建效果元素
        const effectElement = document.createElement('div');
        effectElement.className = `item-effect ${itemType}-effect`;
        
        // 根据道具类型设置不同效果
        switch (itemType) {
            case 'banana':
                // 在警察前方显示香蕉皮
                const policeElement = document.getElementById('police-character');
                if (policeElement) {
                    const policeRect = policeElement.getBoundingClientRect();
                    const sceneRect = gameScene.getBoundingClientRect();
                    
                    effectElement.style.left = `${policeRect.left - sceneRect.left + policeRect.width}px`;
                    effectElement.style.bottom = '0';
                    
                    // 添加警察滑倒动画
                    policeElement.classList.add('slip');
                    setTimeout(() => {
                        policeElement.classList.remove('slip');
                    }, 1000);
                }
                break;
                
            case 'coffee':
                // 在小偷周围显示加速效果
                const thiefElement = document.getElementById('thief-character');
                if (thiefElement) {
                    thiefElement.classList.add('speed-boost');
                    setTimeout(() => {
                        thiefElement.classList.remove('speed-boost');
                    }, 5000);
                }
                break;
                
            case 'shield':
                // 在小偷周围显示护盾效果
                const thiefEl = document.getElementById('thief-character');
                if (thiefEl) {
                    const shieldEffect = document.createElement('div');
                    shieldEffect.className = 'shield-effect';
                    thiefEl.appendChild(shieldEffect);
                    
                    // 一次性效果，使用后移除
                    setTimeout(() => {
                        if (shieldEffect.parentNode) {
                            shieldEffect.parentNode.removeChild(shieldEffect);
                        }
                    }, 2000);
                }
                break;
        }
        
        // 添加到游戏场景
        gameScene.appendChild(effectElement);
        
        // 动画结束后移除
        effectElement.addEventListener('animationend', () => {
            if (effectElement.parentNode) {
                effectElement.parentNode.removeChild(effectElement);
            }
        });
    }
    
    /**
     * 应用道具效果
     * @param {Object} item 道具对象
     */
    applyItemEffect(item) {
        switch (item.effect) {
            case 'slowPolice':
                // 减慢警察速度
                this.game.policeAI.currentSpeed *= 0.7;
                break;
            case 'speedBoost':
                // 提高打字速度 (在游戏循环中处理)
                break;
            case 'errorShield':
                // 免疫一次错误 (在TypingManager中处理)
                break;
        }
    }
    
    /**
     * 更新道具状态
     */
    update() {
        if (!this.currentItem || !this.currentItem.active) {
            return;
        }
        
        const now = Date.now();
        
        // 检查道具是否过期
        if (this.currentItem.duration > 0 && now >= this.currentItem.endTime) {
            // 移除道具效果
            this.removeItemEffect(this.currentItem);
            
            // 清除当前道具
            this.currentItem = null;
            
            // 更新道具显示
            this.updateItemDisplay();
        }
    }
    
    /**
     * 移除道具效果
     * @param {Object} item 道具对象
     */
    removeItemEffect(item) {
        switch (item.effect) {
            case 'slowPolice':
                // 恢复警察速度
                // 警察速度会在下一次更新中自动计算
                break;
            case 'speedBoost':
                // 恢复打字速度
                // 在游戏循环中自动处理
                break;
        }
        
        console.log(`道具效果结束: ${item.name}`);
    }
    
    /**
     * 更新道具显示
     */
    updateItemDisplay() {
        if (!this.itemDisplay) {
            return;
        }
        
        if (this.currentItem) {
            // 显示当前道具
            this.itemDisplay.textContent = `${this.currentItem.icon} ${this.currentItem.name}`;
            
            // 如果道具激活且有持续时间，显示剩余时间
            if (this.currentItem.active && this.currentItem.duration > 0) {
                const now = Date.now();
                const remainingTime = Math.max(0, Math.ceil((this.currentItem.endTime - now) / 1000));
                this.itemDisplay.textContent += ` (${remainingTime}s)`;
            }
        } else {
            // 没有道具
            this.itemDisplay.textContent = '无';
        }
    }
    
    /**
     * 检查是否有激活的道具效果
     * @param {string} effect 效果名称
     * @returns {boolean} 是否有该效果
     */
    hasActiveEffect(effect) {
        return this.currentItem && 
               this.currentItem.active && 
               this.currentItem.effect === effect;
    }
    
    /**
     * 消耗一次性道具
     * @param {string} effect 效果名称
     * @returns {boolean} 是否成功消耗
     */
    consumeOneTimeEffect(effect) {
        if (this.hasActiveEffect(effect) && this.currentItem.duration === 0) {
            // 清除当前道具
            this.currentItem = null;
            
            // 更新道具显示
            this.updateItemDisplay();
            
            return true;
        }
        
        return false;
    }
    
    /**
     * 重置道具系统
     */
    reset() {
        this.currentItem = null;
        this.updateItemDisplay();
    }
    
    /**
     * 检查是否有道具
     * @returns {boolean} 是否有道具
     */
    hasItem() {
        return this.currentItem !== null;
    }
} 